package main

import (
	"encoding/json"
	"fmt"
)

type Person struct {
	Name string // 要序列化，必须导出属性
	Age  int
}

func main() {
	// p1 := Person{"tom", 18}
	// p2 := Person{"ben", 20}
	// fmt.Printf("%+v\n", p1) //序列化，p1打印给你看，字符串，不是 Json
	b, err := json.Marshal([]Person{
		{"tom", 18},
		{"ben", 20},
	})
	if err != nil {
		panic(err)
	}
	fmt.Printf("%+v, %s\n", b, string(b)) // json规则
	fmt.Println("~~~~~~~~~~~~~~~~~~~~~~~~~~~")
	var data = `[
	{"Name":"tom","Age":18},
	{"Name":"ben","Age":20}
]` // json字符串
	// var t interface{}                      // 反序列化成任意类型
	// err = json.Unmarshal([]byte(data), &t) // 反序列化
	// if err != nil {
	// 	panic(err)
	// }
	// fmt.Printf("%T %v\n", t, t) // []interface{} 结构体

	var i []Person                         // 反序列化成Person类型的切片
	err = json.Unmarshal([]byte(data), &i) // 反序列化
	if err != nil {
		panic(err)
	}
	fmt.Printf("%T %v\n", i, i) // []main.Person 结构体切片
	// fmt.Println(i[0] == p1) // 内容相同，go帮你实现了结构体内容比较

	// var data string = `{"Name":"tom","Age":18}` // json字符串
	// // 拿到的数据，反序列化成什么类型，编程的人要有数。反序列化是有可能失败的
	// var i Person                           // 反序列化成Person类型
	// err = json.Unmarshal([]byte(data), &i) // 反序列化
	// if err != nil {
	// 	panic(err)
	// }
	// fmt.Println(i, "#####")
	// fmt.Printf("%T %+[1]v\n", i)
	// // 请问i 和p1 有什么关系？i 和p1类型是相同的吗？是同一个实例吗？
	// // i p1 只是类型相同，是不同类型的实例，碰巧属性值相同
	// fmt.Println(p1 == i) // 内容相同，go帮你实现了结构体内容比较
	// fmt.Println("~~~~~~~~~~~~~~~~~~~~~~~~~~~")

	// var t interface{}
	// err = json.Unmarshal([]byte(data), &t) // var t any = 任意类型值
	// if err != nil {
	// 	panic(err)
	// }
	// fmt.Printf("%T %v\n", t, t) // map[string]interface{} 结构体
}

// 反序列化成interface{}类型，go会帮你转换成map[string]interface{}
// 反序列化成Person类型，go会帮你转换成Person类型
